package controllers

import (
	"encoding/json"
	"fmt"
	"strconv"
	"supershare/backend/models"
	"supershare/backend/services"
	"time"

	"github.com/beego/beego/v2/core/logs"
)

// MeituanGroupOrderController 美团团购订单管理控制器
type MeituanGroupOrderController struct {
	BaseController
}

// List 获取美团团购订单列表
func (c *MeituanGroupOrderController) List() {
	page, pageSize := c.GetPaginationParams()
	storeId, _ := c.GetInt64("store_id", 0)
	meituanId, _ := c.GetInt64("meituan_id", 0)
	meituanGroupId, _ := c.GetInt64("meituan_group_id", 0)
	status := c.GetString("status")
	processStatus := c.GetString("process_status")
	isProcessed, _ := c.GetInt("is_processed", -1)
	isUsed, _ := c.GetInt("is_used", -1)
	startTimeStr := c.GetString("start_time")
	endTimeStr := c.GetString("end_time")

	// 构建过滤条件
	filters := make(map[string]interface{})
	if storeId > 0 {
		filters["store_id"] = storeId
	}
	if meituanId > 0 {
		filters["meituan_id"] = meituanId
	}
	if meituanGroupId > 0 {
		filters["meituan_group_id"] = meituanGroupId
	}
	if status != "" {
		filters["status"] = status
	}
	if processStatus != "" {
		filters["process_status"] = processStatus
	}
	if isProcessed != -1 {
		filters["is_processed"] = isProcessed
	}
	if isUsed != -1 {
		filters["is_used"] = isUsed
	}

	// 处理时间范围
	if startTimeStr != "" {
		startTime, err := strconv.ParseInt(startTimeStr, 10, 64)
		if err == nil {
			filters["start_time"] = startTime
		} else {
			// 尝试解析日期格式，转换为时间戳
			t, err := time.Parse("2006-01-02 15:04:05", startTimeStr)
			if err == nil {
				filters["start_time"] = t.Unix()
			}
		}
	}
	if endTimeStr != "" {
		endTime, err := strconv.ParseInt(endTimeStr, 10, 64)
		if err == nil {
			filters["end_time"] = endTime
		} else {
			// 尝试解析日期格式，转换为时间戳
			t, err := time.Parse("2006-01-02 15:04:05", endTimeStr)
			if err == nil {
				filters["end_time"] = t.Unix()
			}
		}
	}

	// 获取订单列表
	list, total, err := models.GetMeituanGroupOrderList(page, pageSize, filters)
	if err != nil {
		logs.Error("获取美团团购订单列表失败: %v", err)
		c.Fail("获取美团团购订单列表失败")
		return
	}

	c.SuccessWithPagination("获取美团团购订单列表成功", list, total, page, pageSize)
}

// GetOne 获取单个美团团购订单详情
func (c *MeituanGroupOrderController) GetOne() {
	id, ok := c.ValidateIDParam()
	if !ok {
		return
	}

	order, err := models.GetMeituanGroupOrderById(id)
	if err != nil {
		logs.Error("获取美团团购订单详情失败: %v", err)
		c.Fail("获取美团团购订单详情失败")
		return
	}
	if order == nil {
		c.Fail("美团团购订单不存在")
		return
	}

	c.Success("获取美团团购订单详情成功", order)
}

// ProcessOrder 处理美团团购订单
func (c *MeituanGroupOrderController) ProcessOrder() {
	admin, ok := c.GetAdmin()
	if !ok {
		return
	}

	var req struct {
		Id     int64  `json:"id"`
		Status int    `json:"status"` // 1-确认，2-拒绝，3-完成
		Remark string `json:"remark"` // 备注
	}
	if err := json.Unmarshal(c.Ctx.Input.RequestBody, &req); err != nil {
		logs.Error("解析处理美团团购订单请求参数失败: %v", err)
		c.Fail("无效的请求参数")
		return
	}

	// 参数验证
	if err := c.validateProcessOrderRequest(req.Id, req.Status); err != nil {
		c.Fail(err.Error())
		return
	}

	order, err := models.GetMeituanGroupOrderById(req.Id)
	if err != nil {
		logs.Error("获取美团团购订单失败: %v", err)
		c.Fail("获取美团团购订单失败")
		return
	}
	if order == nil {
		c.Fail("美团团购订单不存在")
		return
	}

	if order.IsProcessed == 1 {
		c.Fail("该订单已处理，不能重复操作")
		return
	}

	// 更新备注
	if req.Remark != "" {
		order.Remark = req.Remark
		if err := models.UpdateMeituanGroupOrder(order); err != nil {
			logs.Error("更新美团团购订单备注失败: %v", err)
		}
	}

	if err := models.ProcessMeituanGroupOrder(req.Id, req.Status); err != nil {
		logs.Error("处理美团团购订单失败: %v", err)
		c.Fail("处理美团团购订单失败")
		return
	}

	statusMap := map[int]string{1: "已确认", 2: "已拒绝", 3: "已完成"}
	c.LogOperation(admin, "meituan:group:order:process",
		"处理美团团购订单, ID: "+strconv.FormatInt(req.Id, 10)+", 状态: "+statusMap[req.Status])

	c.Success("处理美团团购订单成功", nil)
}

// UseVoucher 使用美团团购券
func (c *MeituanGroupOrderController) UseVoucher() {
	admin, ok := c.GetAdmin()
	if !ok {
		return
	}

	id, ok := c.ValidateIDParam()
	if !ok {
		return
	}

	order, err := models.GetMeituanGroupOrderById(id)
	if err != nil {
		logs.Error("获取美团团购订单失败: %v", err)
		c.Fail("获取美团团购订单失败")
		return
	}
	if order == nil {
		c.Fail("美团团购订单不存在")
		return
	}

	if order.IsUsed == 1 {
		c.Fail("该团购券已使用，不能重复使用")
		return
	}

	if order.ProcessStatus != "accepted" && order.ProcessStatus != "completed" {
		c.Fail("该团购订单尚未确认，不能使用")
		return
	}

	// 调用美团API同步使用结果
	meituanService, err := services.GetMeituanServiceByStoreId(order.StoreId)
	if err != nil {
		logs.Error("加载美团配置失败: %v", err)
		c.Fail("加载美团配置失败: " + err.Error())
		return
	}

	if err := meituanService.UseVoucher(order.OrderId, order.VoucherCode); err != nil {
		logs.Error("调用美团API使用券码失败: %v", err)
		c.Fail("调用美团API失败: " + err.Error())
		return
	}

	// 使用团购券
	if err := models.UseMeituanGroupOrder(id); err != nil {
		logs.Error("使用美团团购券失败: %v", err)
		c.Fail("使用美团团购券失败")
		return
	}

	// 创建验券记录
	verify := &models.GroupBuyVerify{
		GroupBuyActivityId: 0, // 美团券没有对应的活动ID
		GroupBuyOrderId:    order.Id,
		MemberId:           0,
		StoreId:            order.StoreId,
		OperatorId:         admin.Id,
		OrderAmount:        float64(order.TotalPrice) / 100, // 转换为元
		VerifyTime:         time.Now().Unix(),
		Remark:             fmt.Sprintf("美团团购券核销[订单号:%s]", order.OrderId),
	}

	if _, err := models.CreateGroupBuyVerify(verify); err != nil {
		logs.Error("创建美团验券记录失败: %v", err)
		// 这里不返回错误，因为券已经使用成功
	}

	c.LogOperation(admin, "meituan:group:order:use",
		"使用美团团购券, 订单ID: "+strconv.FormatInt(id, 10)+", 订单号: "+order.OrderId)

	c.Success("使用成功", nil)
}

// SyncOrders 同步美团团购订单
func (c *MeituanGroupOrderController) SyncOrders() {
	admin, ok := c.GetAdmin()
	if !ok {
		return
	}

	storeId, _ := c.GetInt64("store_id", 0)
	meituanGroupId, _ := c.GetInt64("meituan_group_id", 0)

	if storeId <= 0 {
		c.Fail("门店ID不能为空")
		return
	}

	count, err := services.SyncMeituanGroupOrders(storeId, meituanGroupId)
	if err != nil {
		logs.Error("同步美团团购订单失败: %v", err)
		c.Fail("同步美团团购订单失败: " + err.Error())
		return
	}

	c.LogOperation(admin, "meituan:group:order:sync",
		"同步美团团购订单，新增订单数: "+strconv.Itoa(count))

	c.Success("同步美团团购订单成功", map[string]interface{}{"count": count})
}

// validateProcessOrderRequest 验证处理订单请求参数
func (c *MeituanGroupOrderController) validateProcessOrderRequest(id int64, status int) error {
	if id <= 0 {
		return fmt.Errorf("订单ID不能为空")
	}
	if status < 1 || status > 3 {
		return fmt.Errorf("无效的订单状态")
	}
	return nil
}
